import UIKit

/* XCode15的Swift版本5.9 */

/* Swift数组 */
// 类似于Java中的ArrayList类

// 空数组
var createArray = [Int]()
// 另外一种使用泛型的定义方式
var createArray_2 = Array<Int>()
// 注意使用时要初始化，下面两种方式是不对的
// var createArray_3: [Int]
// var createArray_3: Array<Int>
// 创建一个值循环指定次数的已经初始化了的数组
var repeatingArray = [Int](repeating: 10, count: 5)
// 给定了一些值进行了初始化
var someArray: [Int] = [10, 20, 30]

// 访问数组元素的方法同C语言
// 修改给定下标的元素的方式同C语言
// 但是下标仍然不能越界做访问和修改
// someArray[3] = 40

// 延长数组的大小
var shortArray: [Int] = []
// 方法1：使用append方法
shortArray.append(10)
// 方法2：类似字符串连接一个数组
// 使用同样的方法还可以合并数组
shortArray += [20]
print("\(shortArray[0]) \(shortArray[1])")

var someStrs = [String]()
someStrs.append("Apple")
someStrs.append("Amazon")
someStrs += ["Runoob"]
someStrs += ["Google"]
// 遍历数组元素
for item in someStrs {
    print(item)
}
// 还可以同时获取下标的值
for (index, item) in someStrs.enumerated() {
    print("\(index)----\(item)")
}

// 使用count属性来获取数组元素的个数
print(someStrs.count)

// 使用isEmpty属性来判断数组是否为空
print(someStrs.isEmpty)
print(createArray.isEmpty)

// 使用swap函数交换元素的位置
someArray.swapAt(0, 2)
print(someArray)

// 使用sort对数组进行排序
someArray.sort()
print(someArray)

// 使用contains检索特定的元素
someArray.contains(10)
someArray.contains(40)

/* Swift数组片段 */
var someSlice = someArray[1...2]
// 下标还是用的原来被引用的数组的下标，并不是用新的下标
print(someSlice[1])
// 片段的内容与原来的数组是相同的
// 在早期的Swift中，修改数组片段会直接影响到原数组
// 但是在Swift5中已经不会影响到原数组了
someSlice[1] = 999
print(someArray[1])
// 由数组片段生成新的数组，数组下标将重新从0开始
let sliceArray = Array(someArray[1...2])
print(sliceArray[1])

/* Swift字典 */
// 类似于Java中的HashMap类
// 存储无序且相同类型数据的集合

// key的类型可以是整型，也可以是字符串
// ！！！但是key必须是唯一的

// 将字典赋给常量，不仅常量的指向是不能改变的
// ！！！字典本身也是不能改变的

var DictA = [Int: String]()
// 另外一种使用泛型的定义方式
var DictA_2 = Dictionary<Int, String>()
// 注意使用时要初始化，下面两种方式是不对的
// var DictA_3: [Int: String]
// var DictA_3: Dictionary<Int,String>
var DictB: [Int: String] = [1: "One", 2: "Two", 3: "Three"]

// ！！！访问字典内容，访问返回的结果是一个可选类型
var DictB_2 = DictB[2]
// 尝试访问不存在的key对应的值，将会返回nil
var DictB_4 = DictB[4]

print(DictB_2 ?? "DictB_2 is nil")
print(DictB_4 ?? "DictB_4 is nil")

// 修改或增加字典的内容
// 方法1:使用updateValue方法
// 返回key对应的之前的值，是一个可选类型
var oldVal_1 = DictB.updateValue("One N", forKey: 1)
print(oldVal_1 ?? "oldVal_1 is nil")

// 如果key不存在，将返回nil，并且将给定的key-value对插入
var oldVal_4 = DictB.updateValue("Four N", forKey: 4)
print(oldVal_4 ?? "oldVal_4 is nil")

// 方法2:类似于数组一样直接改变修改
DictB[3] = "Three N"
print(DictB[3] ?? "DictB[3] is nil")
// 也可以针对不存在的key操作，这样操作就能增加新的
DictB[5] = "Five N"
print(DictB[5] ?? "DictB[5] is nil")

// 移除字典的内容
// 方法1:使用removeValue方法
var removeVal_5 = DictB.removeValue(forKey: 5)
print(DictB[5] ?? "DictB[5] is nil")

// 方法2:类似于数组一样给指定下标nil
DictB[3] = nil
print(DictB[4] ?? "DictB[3] is nil")

// 遍历字典
// 就算key是整型，这样遍历的顺序也不一定是递增或者递减的顺序
// 遍历输出的顺序是随机的，每一次运行的结果都不同
for (key, value) in DictB {
    print("\(key) : \(value)")
}

// 这样返回的i表示当前遍历到了第几个元素
// 依然是随机顺序，不过与上面的遍历方法得到的结果是一样的
// value返回的是key-value对
for (i, value) in DictB.enumerated() {
    print("\(i) : \(value.key) - \(value.value)")
}

// 字典转换为数组
var dictBKeys = [Int](DictB.keys)
var dictBValues = [String](DictB.values)

for key in dictBKeys {
    print("\(key)")
}

for value in dictBValues {
    print("\(value)")
}

// count属性表示有多少个key-value对
print("\(DictB.count)")

// isEmpty属性表示这个字典是否为空字典
print("\(DictB.isEmpty)")

/* Swift集合 */
// 初始化一个集合的两种方式
// 创建一个空集合
var weatherOfSanya = Set<String>()
weatherOfSanya = ["rainy", "sunny", "stormy"]
// 给定一些值进行初始化，可以自动判断类型
var weatherOfBeijing : Set = ["dry", "windy", "frogy", "sunny"]
var weatherOfBeijing_copy : Set = ["dry", "windy", "frogy", "frogy"]

// 使用isEmpty属性来判断集合是否为空
if weatherOfSanya.isEmpty {
    print("The set of weather is empty!")
} else {
    print("There are \(weatherOfSanya.count) kinds weather!")
}

// 插入一个元素
weatherOfSanya.insert("cloudy")
// 重复元素，可以通过返回值的inserted判断是否成功插入
weatherOfSanya.insert("sunny")

// 删除元素
// 返回被删除的元素
weatherOfSanya.remove("stormy")
// 如果这个元素不存在而被移除，将返回nil
weatherOfSanya.remove("dry")

// 使用contains检索特定的元素
if weatherOfSanya.contains("sunny") {
    print("Sanya is sunny sometimes.")
}

// 遍历Set
for weather in weatherOfSanya {
    print("\(weather)")
}

// 使用sorted对集合进行排序
for weather in weatherOfSanya.sorted() {
    print("\(weather)")
}

// 交集
weatherOfBeijing.intersection(weatherOfSanya)
// 并集
weatherOfBeijing.union(weatherOfSanya)
// 差集
weatherOfBeijing.subtracting(weatherOfSanya)
// 直接减掉
print(weatherOfBeijing)
weatherOfBeijing.subtract(weatherOfSanya)
print(weatherOfBeijing)
